home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / PowerMacOberon 1.2 / Debugger / RTDC.Mod (.txt) < prev    next >
Oberon Text  |  1995-06-16  |  8KB  |  200 lines
  1. Syntax10.Scn.Fnt
  2. StampElems
  3. Alloc
  4. 16 Jun 95
  5. InfoElems
  6. Alloc
  7. Syntax10.Scn.Fnt
  8. StampElems
  9. Alloc
  10. 16 Jun 95
  11. "Title": Run time debugger
  12. "Author": mah
  13. "Abstract": Compiler information grabber
  14. "Keywords": 
  15. "Version": 
  16. "From":  25.10.94 16:53:38
  17. "Until": 
  18. "Changes": 
  19. ParcElems
  20. Alloc
  21. Syntax10i.Scn.Fnt
  22. Syntax10b.Scn.Fnt
  23. FoldElems
  24. Syntax10.Scn.Fnt
  25. Syntax10b.Scn.Fnt
  26.         pc-: POINTER TO ARRAY OF SHORTINT;
  27.         pos-: POINTER TO ARRAY OF LONGINT;
  28.     END;
  29. Syntax10.Scn.Fnt
  30. Syntax10i.Scn.Fnt
  31.         name: ARRAY 32 OF CHAR;                        (* modul name of entry *)
  32.         mod: Modules.Module;                            (* modul descriptor *)
  33.         sym: Sym;                                        (* symbol info of module 'name' *)
  34.         stat: Stat;                                        (* statements of module 'name' *)
  35.     END;
  36. Syntax10.Scn.Fnt
  37. Syntax10i.Scn.Fnt
  38.     pos, i: INTEGER;
  39.     indexcheckoff, typecheckoff: BOOLEAN;
  40.     trap: Modules.TrapDescPtr;
  41. BEGIN
  42.     indexcheckoff := TRUE; typecheckoff := TRUE; pos := 1; o[0] := 'n';
  43.     FOR i := 0 TO mod.noftraps-1 DO
  44.         trap := SYS.VAL (Modules.TrapDescPtr, mod.traps+i*SIZE (Modules.TrapDesc));
  45.         CASE trap.trapno OF
  46.             1: indexcheckoff := FALSE    (* has index check -> no 'x' parameter *)
  47.         |    4: typecheckoff := FALSE        (* has type check -> no 't' parameter *)
  48.         |    7: pos := 0                    (* has NIL check -> no 'n' parameter *)
  49.         ELSE
  50.         END
  51.     END;
  52.     IF indexcheckoff THEN o[pos] := 'x'; INC (pos) END;
  53.     IF typecheckoff THEN o[pos] := 't'; INC (pos) END;
  54.     o[pos] := 'f'; o[pos+1] := CHR(0)        (* add findpc option *)
  55. END GetOptions;
  56. Syntax10.Scn.Fnt
  57. BEGIN
  58.     WHILE (obj # NIL) & (obj.name # name) DO
  59.         IF name < obj.name THEN  obj := obj.left
  60.         ELSE  obj := obj.right END
  61.     END;
  62.     RETURN obj
  63. END Find;
  64. Syntax10.Scn.Fnt
  65. VAR cnt: INTEGER; s: OPV.Stats; i: INTEGER;
  66. BEGIN
  67.     s := OPV.stats; cnt := 0;
  68.     WHILE s # NIL DO INC (cnt, s.numStat); s := s.next END;
  69.     NEW (stat.pc, cnt); NEW (stat.pos, cnt);
  70.     s := OPV.stats; cnt := 0;
  71.     WHILE s # NIL DO
  72.         FOR i := 0 TO s.numStat-1 DO
  73.             stat.pc[cnt+i] := s.pc[i];
  74.             stat.pos[cnt+i] := s.pos[i];
  75.         END;
  76.         INC (cnt, s.numStat); s := s.next
  77. END ConvertStats;
  78. Syntax10.Scn.Fnt
  79. Syntax10i.Scn.Fnt
  80.     slot, i: INTEGER;
  81.     name: ARRAY 36 OF CHAR;
  82.     source, out: Texts.Text;
  83.     r: Texts.Reader;
  84.     option: ARRAY 5 OF CHAR;
  85.     err: BOOLEAN;
  86. BEGIN
  87.     slot := 0;
  88.     WHILE (slot # maxnofmods) & (mod.name # modCache[slot].name) DO INC (slot) END;
  89.     IF slot = maxnofmods THEN slot := nextslot
  90.     ELSIF modCache[slot].mod = mod THEN RETURN slot END;
  91.     COPY (mod.name, name);
  92.     i := 0; WHILE name[i] # 0X DO INC (i) END;
  93.     name[i] := '.'; name[i+1] := 'M'; name[i+2] := 'o'; name[i+3] := 'd'; name[i+4] := CHR(0);
  94.     source := TextFrames.Text (name);
  95.     IF source.len = 0 THEN RETURN -1 END;
  96.     FoldElems.ExpandAll (source, 0, TRUE);
  97.     Texts.OpenReader (r, source, 0);
  98.     out := TextFrames.Text ("");
  99.     GetOptions (mod, option);
  100.     Compiler.Module (r, option, 0, out, err);
  101.     IF (Compiler.mainMod = NIL) OR (OPV.stats = NIL) THEN RETURN -1 END;
  102.     modCache[slot].mod := mod;
  103.     modCache[slot].sym := Compiler.mainMod;
  104.     COPY (mod.name, modCache[slot].name);
  105.     ConvertStats (modCache[slot].stat);
  106.     IF slot = nextslot THEN nextslot := (nextslot+1) MOD maxnofmods END;
  107.     Compiler.mainMod := NIL;                            (* help garbage collector *)
  108.     OPV.stats := NIL;    
  109.     RETURN slot
  110. END LoadModule;
  111. Syntax10.Scn.Fnt
  112. VAR i: INTEGER;
  113. BEGIN
  114.     FOR i := 0 TO maxnofmods-1 DO
  115.         modCache[i].mod := NIL;
  116.         modCache[i].sym := NIL;
  117.         modCache[i].stat.pc := NIL;
  118.         modCache[i].stat.pos := NIL
  119.     END;
  120.     nextslot := 0
  121. END Release;
  122. Syntax10.Scn.Fnt
  123.     PROCEDURE Scan (o: Sym);
  124.     BEGIN IF o # NIL THEN Scan (o.left); proc (o); Scan (o.right) END
  125.     END Scan;
  126. BEGIN Scan (scope)
  127. END ScanScope;
  128. Syntax10.Scn.Fnt
  129. VAR idx: INTEGER;
  130. BEGIN
  131.     idx := LoadModule (Modules.ThisMod (name));
  132.     IF idx = -1 THEN stats.pc := NIL ELSE stats := modCache[idx].stat END
  133. END Statements;
  134. Syntax10.Scn.Fnt
  135. VAR idx: INTEGER;
  136. BEGIN
  137.     idx := LoadModule (Modules.ThisMod (name));
  138.     IF idx = -1 THEN syms := NIL ELSE syms := modCache[idx].sym END
  139. END Symbols;
  140. Syntax10.Scn.Fnt
  141. Syntax10i.Scn.Fnt
  142. VAR sym: Sym;
  143. BEGIN
  144.     Symbols (type.module.name, sym);
  145.     IF sym = NIL THEN Symbols (module.name, sym) END;    (* get info of type as imported in module *)
  146.     ASSERT (sym # NIL);
  147.     RETURN Find (sym, type.name)
  148. END FindType;
  149. MODULE RTDC; (* Run time debugger: Compiler reference & position information; mah 25.10.94 (
  150. IMPORT OPV := POPV, OPT := POPT, Modules, SYS := SYSTEM, Texts, TextFrames, Compiler, Types, FoldElems, RTDT;
  151. CONST
  152.     maxnofmods = 5;                                        (* cache size: max # of modules cached *)
  153.     Sym* = OPT.Object;                                    (* alias to hide compiler type *)
  154.     Type* = OPT.Struct;
  155.     Stat* = RECORD
  156.     ModuleCache = RECORD 
  157.     ScanProc*  = PROCEDURE (obj : Sym);                (* iterator type for scanning scopes *)
  158.     nextslot: INTEGER;                                         (* next slot to be used  in cache (round robin) *)
  159.     modCache: ARRAY maxnofmods OF ModuleCache;    (* modul cache *)
  160. PROCEDURE GetOptions (mod: Modules.Module; VAR o: ARRAY OF CHAR);
  161. PROCEDURE Find (obj: Sym; VAR name: ARRAY OF CHAR) : Sym;
  162. PROCEDURE ConvertStats (VAR stat: Stat);
  163. PROCEDURE LoadModule (mod: Modules.Module) : INTEGER;
  164. PROCEDURE Release*;
  165. PROCEDURE ScanScope* (scope: Sym; proc: ScanProc);
  166. PROCEDURE Statements* (name: ARRAY OF CHAR; VAR stats: Stat);
  167. PROCEDURE Symbols* (name: ARRAY OF CHAR; VAR syms: Sym);
  168. PROCEDURE FindType* (type: Types.Type; module: Modules.Module) : Sym;
  169. PROCEDURE FindProc* (proc : RTDT.Proc) : Sym;
  170.     o, parentScope: Sym;
  171.     parentProc: RTDT.Proc;
  172.     mod: Modules.Module;
  173.     i, j: INTEGER;
  174.     n: ARRAY 64 OF CHAR;
  175. BEGIN
  176.     i := 0; WHILE (proc.name[i] # 0X) & (proc.name[i] # '.') DO INC (i) END;
  177.     IF proc.name[i] = '.' THEN            (* typebound   typename.procname *)
  178.         COPY (proc.name, n); n[i] := 0X;
  179.         Symbols (proc.modName, o);
  180.         o := Find (o, n);
  181.         j := 0; REPEAT n[j] := proc.name[i+1]; INC (i); INC (j) UNTIL proc.name[i] = 0X;    
  182.         IF o.typ.form = 13 THEN o := o.typ.BaseTyp.strobj END;     (* pointer as self parameter *)
  183.         o := Find (o.typ.link, n);
  184.         RETURN o.scope.right
  185.     ELSE        (* normal or local procedure (takes care of local procedures) *)
  186.         parentProc := proc.up;
  187.         WHILE (parentProc # NIL) & (parentProc.modName = proc.modName) DO
  188.             parentScope := FindProc (parentProc);
  189.             IF parentScope # NIL THEN
  190.                 o := Find (parentScope, proc.name);
  191.                 IF o#NIL THEN RETURN o.scope.right END
  192.             END;
  193.             parentProc := parentProc.up
  194.         END;
  195.         Symbols (proc.modName, o);
  196.         o := Find (o, proc.name);
  197.         RETURN o.scope.right
  198. END FindProc;
  199. END RTDC.
  200.